Get the default tenant ID

{ getDefaultTenant }

Returns the ID of the default tenant in the system.

Method

/API2/access/getDefaultTenant

  • API Section: /API2/access
  • API Version: 2.0
  • From Release: 2018.5
  • Method operates via POST actions only.
  • Output Response

    Successful Result Code

    200

    Description of Response Type

    successful operation

    Examples
    Create new Active Directory user (JavaScript):

    This example demonstrates how to find and add a new user and roles in Pyramid, when using Active Directory authentication.

    The example uses API authentication driven from JavaScript. See Authentication APIs for alternatives.

    // URL of the Pyramid installation and the path to the API 2.0 REST methods
    var pyramidURL = "http://mysite.com/api2/";
    
    // step 1: authenticate admin account and get token. 
    //This assumes authentication with Windows Authentication SSO. Therefore the account logging on is an admin account.
    // NOTE: callApi method is a generic REST method shown below. And inside it, xhttp.withCredentials = true;
    				
    let token = callApi("auth/authenticateUserWindows",{},false); 
    log("got token "+token);
    
    //step 2: Get the defult tenant.
    let defaultTenantResult = callApi("access/getDefaultTenant",{
    	"auth": token // admin token generated above
    });
    let tenantId = defaultTenantResult.data;
    log("default tenant, id= "+tenantId);
    
    //step 3: search for an active directory user in the AD itself
    let searchUsers=callApi("access/searchAdUsers",{
    	"ldapUsersSearch":{
    		"domainNetBios":"myAdDomain",
    		"searchValue":"Smith",
    		"ldapSearchType": 0, //search type enumeriation. 0 = exact
    	},
    	"auth": token // admin token generated above
    });
    
    
    let adUser = searchUsers.data[0];
    log("adUser = "+adUser.firstName);
    
    //step 4: creating a user using the results from the search in step 3
    let createUser = callApi("access/createAdUser",{
    	"newLdapUser": {
    	"userName": adUser.userName, //using the search result from step 3 above
    	"adminType": 0, //admin type
    	"clientLicenseType": 100,//ClientLicenseType.Viewer
    	"statusID": 1,
    	"tenantId": tenantId, //tenant Id from above
    	"adDomainName":"myAdDomain" 
    	},
    	"auth": token // admin token generated above
    });
    let userId = createUser.data.modifiedList[0].id;
    log("created user "+userId);
    
    
    //step 5: optional, changing the user from Viewer to Professional
    let updateUser=callApi("access/updateAdUsers",{
    	"updateLdapUser":[{
    		"userName": adUser.userName,
    		"adDomainName":"myAdDomain",
    		"clientLicenseType": 200,//ClientLicenseType.Professional
    	}],
    	"auth": token
    });
    
    
    //step 6: creating 2 roles
    let createRole=callApi("access/createRoles",{
    	"data": [{
    		"roleName": "role1",
    		"tenantId": tenantId,
    		"isGroupRole": false
    	},{
    		"roleName": "role2",
    		"tenantId": tenantId,
    		"isGroupRole": false
    	}],
    	"auth": token
    });
    
    let role1 = createRole.data.modifiedList[0].id;
    let role2 = createRole.data.modifiedList[1].id;
    log("created roles "+role1+","+role2);
    
    //step 7: binding user to role1 from step 6
    let addUserToRole=callApi("access/addUserToRole",{
    	"addUserRoleData": {
    		"userId":userId,
    		"roleId":role1
    	},
    	"auth": token
    });
    
    
    //step 8: searchAdGroupsForUser, searching for AD groups of the given user in the given domain
    let groups=callApi("access/searchAdGroupsForUser",{
    	"searchData": {
    		"domainNetBios":"myAdDomain",
    		"userName":adUser.userName
    	},
    	"auth": token
    });
    log("groups of " + adUser.userName" + "+JSON.stringify(groups.data));
    let selectedGroup=groups.data[0];
    
    
    //step 9: add role2 to the AD security group from step 8
    let addRoleToAdGroup=callApi("access/changeRoleAdGroupMembership",{
    	"roleAdGroups": {
    		"roleId":role2,
    		"groupsToAdd":[{
    			"domainNetBios":selectedGroup.domainAddress,
    			"groupName":selectedGroup.name
    		}]
    	},
    	"auth": token
    });
    log("addRoleToAdGroup "+JSON.stringify(addRoleToAdGroup));
    
    //step 10: optional get all groups by role - this will find the selected Group from step 9
    let groupsFound=callApi("access/getGroupsByRole",{
    	"roleId":role2,
    	"auth": token
    });
    log("found group "+groupsFound.data[0].name);
    
    // ##### optional generic logging method for debugging ##############
    function log(msg){
    	document.write(msg);
    	console.log(msg);
    }
    
    // ##### generic REST API calling method ##############
    function callApi(path,data,parseResult=true){
    	var xhttp = new XMLHttpRequest();
    	
    	//notice we changed callApi and added xhttp.withCredentials = true; to pass the windows credentials
    	xhttp.withCredentials = true;
    	
    	xhttp.open("POST", pyramidURL+path, false);
    	xhttp.send(JSON.stringify(data));
    	if(parseResult){
    		return JSON.parse(xhttp.responseText);
    	}else{
    		return xhttp.responseText;
    	}
    }
    
    
    		
    Content Operations (JavaScript):

    This example demonstrates how to manage content items in Pyramid.

    The example uses API authentication driven from JavaScript. See Authentication APIs for alternatives.

    // URL of the Pyramid installation and the path to the API 2.0 REST methods
    var pyramidURL = "http://mySite.com/api2/";
    
    // step 1: authenticate admin account and get token
    // NOTE: callApi method is a generic REST method shown below.
    let token = callApi("auth/authenticateUser",{
    	"data":{
    		"userName":"adminUser",
    		"password":"abc123!"
    	}
    },false);
    log("got token "+token);
    
    //step 2: get the default tenant ID
    let defaultTenant=callApi("access/getDefaultTenant",{
    	"auth": token // admin token generated above
    }).data;
    
    //step 3: return the ID of the public root folder for the tenant from step 2
    let tenentPublicFolder = callApi("content/getPublicOrGroupFolderByTenantId",{
    	"folderTenantObject": {
    		"validRootFolderType": 1,//the public folder of the default tenant
    		"tenantId": defaultTenant
    	},
    	"auth": token //admin token generated from step 1 above
    }).data;
    
    //step 4: add a new folder to the public folder from step 3
    let folderCreation = callApi("content/createNewFolder",{
    	"folderTenantObject": {
    		"parentFolderId": tenentPublicFolder.id,
    		"folderName": "new folder"
    	},
    	"auth": token
    }).data;
    let folderId=folderCreation.modifiedList[0].id;
    
    //step 5: find roles
    let findRole = callApi("access/getRolesByName",{
    	"data": {
    		"searchValue": "role1",
    		"searchMatchType": 2//SearchMatchType.Equals
    	},
    	"auth": token
    });
    let roleId=findRole.data[0].roleId;
    log("found role with id= "+ roleId);
    
    //step 6:add the role we found in step 5 to the folder we created (folderId) in step 4
    let addRoleToFolder= callApi("content/addRoleToItem",{
    	"roleToItemApiData": {
    		"itemId": folderId,
    		"roleId": roleId//SearchMatchType.Equals
    	},
    	"auth": token
    });
    
    //step 7: read in a Pyramid Import/Export ('PIE') file
    let file="http://myOtherSite.com/Sample.pie";
    let pieFile=readPieFile(file);
    
    //step 8: import the PIT file into the folder from step 4
    let importContent = callApi("content/importContent",{
    	"pieApiObject": {
    		"rootFolderId": folderId, //from step 4
    		"fileZippedData": pieFile, //the file's content from step 7
    		"clashDefaultOption":1,//ClashDefaultOption.REPLACE_FILE like default
    		"rolesAssignmentType":3//RoleAssignmentType.ForceParentFolderRoles take roles from parent folder
    	},
    	"auth": token
    }).data;
    let itemId=Object.keys(importContent.importDscMap)[0];
    
    //step 9: optional, search for the item we just imported, it's id is itemId
    let findContentItem = callApi("content/findContentItem",{
    	"searchParams":{
    		"searchString":"import",
    		"filterTypes":[3],//ContentTypeObject.DataDiscoveryv
    		"searchMatchType":2,//SearchMatchType.Equals
    		"searchRootFolderType":1//SearchRootFolderType.Public
    		
    	},
    	"auth": token
    }).data;
    
    
    //step 10: check if you need to run datasource changer 
    // (since the datasource that created this report dosen't exists on this server)
    if(importContent.importDscMap[itemId][0].needsToPerformDsc){
    
    	step 10A: get item's data source connection
    	let correntConnectionStringId=importContent.importDscMap[itemId][0].connectionStringProperties.id
    	
    	//step 10B: run the data source changer on the items
    	let changedDatasource = callApi("dataSources/changeDataSource",{
    		"dscApiData":{
    			"fromConnId":correntConnectionStringId,
    			"toConnId":"55ff277a-53ff-4c39-8f15-5651f1026a2d",//retrive this id using 'getAllConnectionStrings'
    			"itemId":itemId
    		},
    		"auth": token
    	});
    }
    
    //step 11: copying the imported item to the tenant root folder
    let copyItems = callApi("content/copyItems",{
    	"moveItemsObject":{
    		"itemsForMove":[itemId],
    		"destinationFolder":tenentPublicFolder.id		
    	},
    	"auth": token
    }).data;
    
    //step 12: remove roles from the folder but not from the item
    let removeRoleFromCreatedFolder= callApi("content/removeRolesFromItem",{
    	"rolesInItemRemovalObject": {
    		"itemId": folderId,
    		"roleIds": [roleId]
    	},
    	"auth": token
    });
    
    //step 13: hard delete the folder (permanently)
    let folderDeletion = callApi("content/purgeContentItems",{
    	"itemIds":[folderCreation.modifiedList[0].id],
    	"auth": token
    });
    
    //step 14: soft-delete the items
    let itemSoftDeletion = callApi("content/softDeleteContentItems",{
    	"itemIds":[copyItems.modifiedList[0].id],
    	"auth": token
    });
    
    
    
    
    function log(msg){
    	document.write(msg);
    	console.log(msg);
    }
    
    function callApi(path,data,parseResult=true){
    	var xhttp = new XMLHttpRequest();
    	xhttp.open("POST", pyramidURL+path, false);
    	xhttp.send(JSON.stringify(data));
    	if(parseResult){
    		return JSON.parse(xhttp.responseText);
    	}else{
    		return xhttp.responseText;
    	}
    }
    
    //example function to read in the contents of a 'PIE' file that contains
    //exported Pyramid content.
    function readPieFile(file){
    	var rawFile = new XMLHttpRequest();
    	rawFile.open("GET", file, false);
    	rawFile.send(null);
    	rawFile.onreadystatechange = function () {
    		if (request.readyState === 4 && request.status === 200) {
    			return request.responseText;
            }
        }
    }